COMMENT ⊗   VALID 00005 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	.SBTTL	Basic TTY input and output routines
C00003 00003	 TTY output routines  TYPSTR, TYPDEC, TYPOCT, TYPCHR
C00006 00004	 Macros:  OUTSTR, NUMOUT, ASCIE, CRLF, HALERR, ERRTRAP
C00009 00005	 VT05 INPUT ROUTINE - "INSTR", system line buffers
C00012 ENDMK
C⊗;
.SBTTL	Basic TTY input and output routines
.EVEN

; TTY output routines  TYPSTR, TYPDEC, TYPOCT, TYPCHR

;  Modified 5-Sep-74 by RF.  Originally written by KKP.

;	Output a string, ending with a zero character. Pointer to start
;	of string in R0.  Called in "simple" style.

TYPSTR:	MOV R0,R1	;R1 ← LOC[STRING]
	MOVB (R1)+,R0	;R0 ← first byte of string
TSLOOP:	BEQ TYPS1	;If null, exit now.
	JSR PC,TYPCHR	;Type this one character
	MOVB (R1)+,R0	;R0 ← Next byte of string
	BNE TSLOOP	;If more to come, repeat.
TYPS1:	RTS PC		;Done


; Routines to output numbers.  Argument in R0.
; TYPDEC outputs in base 10, and TYPOCT in base 8.
; Both use TYPDIG as a subroutine, putting the digit
;	in R0.
; TYPCHR is a general purpose character output routine.
;	It looks at OUTSW to see where to direct the output.

TYPDEC:	MOV #12,RADIX	;To output in base 10
	BR TYPDIG	;Go type it.
TYPOCT:	MOV #8,RADIX	;To output in base 8.
	BR TYPDIG	;Go type it.
TYPDIG:	MOV R0,R1	;Need dividend in R1, with R0 clear.
	CLR R0		;Clear upper half of dividend.
	DIV (PC)+,R0	;Divide argument in R0, R1 by radix.
RADIX:	12		;Starts out in decimal.
	BEQ TYPOUT	;If quotient zero, then can print.
	MOV R1,-(SP)	;Else stack quotient
	JSR PC,TYPDIG	;Recursive call.
	MOV (SP)+,R1	;Unstack last quotient
TYPOUT:	ADD #'0,R1	;Form TTY code for digit
	MOV R1,R0	;Need argument for TYPCHR in R0.
TYPCHR:	TST OUTSW	;VT05 or console?
	BEQ TYPCH1	;
	TSTB KBOS	;VT05: Is it available?
	BPL TYPCHR	;No.  Busy wait for it.
	MOVB R0,KBOR	;Yes.  Output a byte to it.
	CMP #12,R0	;Was it a line feed?
	BNE TYPRET	;If not that code, then done.
	CLR R0		;Otherwise, output 3 nulls.
	JSR PC,TYPCHR	;
	JSR PC,TYPCHR	;
	JMP TYPCHR	;Direct jump; it will return to caller.
TYPCH1:	TSTB OREG	;Console:  Ready?
	BNE TYPCHR	;No.
	MOVB R0,OREG	;Yes.  Output a byte to it.
TYPRET:	RTS PC		;Return.
; Macros:  OUTSTR, NUMOUT, ASCIE, CRLF, HALERR, ERRTRAP

       .MACRO OUTSTR B	;Type string starting at B.
	MOV R0,-(SP)	;Save R0.  Who knows what was happening in it?
	MOV R1,-(SP)	;Save R1.
	MOV #B,R0	;Load up the string to be output
	JSR PC,TYPSTR	;Call the string output utility routine.
	MOV (SP)+,R1	;Restore R1.
	MOV (SP)+,R0	;Restore R0.
       .ENDM

       .MACRO NUMOUT	;Type out the number in AC0 with CVG using OUTBUF
	MOV R0,-(SP)	;Save the registers
	MOV R1,-(SP)
	STF AC0,-(SP)
	STF AC1,-(SP)
	MOV #OUTBUF,R0	;Use OUTBUF to construct the string
	JSR PC,CVG	;Convert floating point number to asc
	LDF (SP)+,AC1   ;Restore the floating point registers
	LDF (SP)+,AC0
	MOV #OUTBUF,R0	;Set pointer for i/o routine
	JSR PC,TYPSTR	;Type out the number
	MOV (SP)+,R1	;Restore the registers
	MOV (SP)+,R0
       .ENDM

       .MACRO ASCIE STR
       .ASCIZ STR
       .EVEN
       .ENDM

       .MACRO	CRLF
	OUTSTR CRLFX	;Carriage return, line feed.
       .ENDM

CRLFX: .ASCIZ /
/

RUGMES:	ASCIE </π
--ONLY DDT CAN HELP YOU NOW!
π/>

       .MACRO HALERR MES	;Bad error.  Type message, call debugger.
	MOV #MES,-(SP)	;Push the message pointer.
	JSR PC,ERRTRAP	;No need to save registers.  This is done in ERRTRAP.
       .ENDM

ERRTRAP:
; Pointer to message is on stack.  Print it, restore state, go to DDT
	MOV R0,-(SP)	;Save R0.
	MOV R1,-(SP)	;Save R1.
	MOV #CRLFX,R0	;Move to new line
	JSR PC,TYPSTR	;
	MOV 6(SP),R0	;Type out message
	JSR PC,TYPSTR	;
	MOV #RUGMES,R0	;Type out RUGMES
	JSR PC,TYPSTR	;
	MOV (SP)+,R1	;Restore R1.
	MOV (SP)+,R0	;Restore R0.
	MOV (SP)+,(SP)	;put return address only on stack.
	BPT		;Breakpoint to DDT.
	RTS PC		;Return to calling point.

; VT05 INPUT ROUTINE - "INSTR", system line buffers

;STRING BYTE POINTER MUST BE  IN R0.  A CARRIAGE RETURN  IS ASSUMED TO
;BE  THE  ACTIVATION CHARACTER.  A  RUB OUT  IS  A  DELETING BACKSPACE
;CHARACTER.  AT  THE COMPLETION OF  THIS ROUTINE  A NULL CHARACTER  IS
;PLACED IN THE INPUT STRING.  R0 THEN POINTS TO THE NULL CHARACTER.

;REGISTERS USED:
;
;	R0 PASSES ARGUMENT
;	R1 GARBAGED

INSTR:	CLR	CCNT		;RESET CHARACTER COUNT
IN2:  	TSTB	KBIS		;TEST IF KEYBOARD READY
	BEQ	.-4		;WAIT TILL IT IS
	MOVB	KBIR,R1		;GET A CHARACTER
	BIC     #177600,R1		;MASK OFF - MAKE IT 7 BITS
	CMP	R1,#177		;COMPARE TO BS CHARACTER
	BNE	IN3		;SKIP IF ITS NOT
	TST	CCNT		;CHECK IF ANY CHARACTERS IN BUFFER
	BEQ	IN2		;FORGET BACK SPACE IF NO CHAR.
	DEC     R0   		;REMOVE LAST CHARACTER IN BUFFER
	DEC	CCNT		;DECREMENT CHARACTER COUNT
	OUTSTR  DBS		;PERFORM A DELETING BACKSPACE
	JMP     IN2
IN3:	CMP	R1,#15		;COMPARE TO CR CHARACTER
	BEQ     IN4   		;CONTINUE READING IF ITS NOT A CR
	CMP	R1,#40		;CHECK IF CHARACTER LEGAL
	BLT	IN2		;IGNOR IF IT IS
    	MOVB	R1,(R0)+	;SAVE THE CHARACTER
    	INC	CCNT		;INCREMENT CHARACTER COUNT
     	TSTB	KBOS		;ECHO THE CHARACTER
	BPL	.-4		;WAIT TILL TTY READY
	MOVB	R1,KBOR		;WRITE THE CHARACTER
	JMP	IN2		;CONTINUE READING
IN4:  	CRLF			;IF IT IS A CR, TYPE A CR AND LF
	MOVB	R1,(R0)+	;PUT A CR IN THE STRING
	MOVB    #0,(R0)		;PUT IN A NULL CHARACTER
	RTS	PC		;RETURN
CCNT:	0
DBS:	.BYTE	10,40,10,0

;System line buffers

INBUF:	.BLKW	42.
OUTBUF:	.BLKW	42.
CURIN:	INBUF		;Current line pointer